﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Drawing;

namespace FeiYang
{
    public class 表项_
    {
        public int 页 { get; set; }
        public Point 点 { get; set; }
        public int 数量 { get; set; }
        public 表项_(int 页, Point 点, int 数量)
        {
            this.页 = 页;
            this.点 = 点;
            this.数量 = 数量;
        }
    }
    class 包裹_
    {
        public static Point 第一页位置 = new Point(1128, 246);
        public static Point 第二页位置 = new Point(1128, 246 + 91);
        public static Point 第三页位置 = new Point(1128, 246 + 91 * 2);
        public long 金币数量 = 0;
        public long 元宝数量 = 0;
        private int[] 物品分类表 = new int[(int)_物品_.最大_];
        public Point 包裹图标位置 = new Point(891, 725);
        public Point 整理位置 = new Point(827, 512);
        public Point 一键回收 = new Point(353, 505);
        public _物品_[] 快捷栏 = new _物品_[] { _物品_.其他_, _物品_.其他_, _物品_.其他_, _物品_.其他_, _物品_.其他_ };
        public Point 快捷随机位 = new Point(-1, -1);
        public Point 快捷回城石位 = new Point(-1, -1);
        public 表项_ 东部矿区飞书 { get; set; }
        public 表项_ 造化堂飞书 { get; set; }
        public 表项_ 五蛇殿飞书 { get; set; }
        public 表项_ 逆魔六飞书 { get; set; }
        public 表项_ 将军三飞书 { get; set; }

        public 表项_ 地下七飞书 { get; set; }
        public 表项_ 叹息飞书 { get; set; }
        public 表项_ 尸上行飞书 { get; set; }
        public 表项_ 九不回飞书 { get; set; }
        public 表项_ 八仙纵横飞书 { get; set; }
        public 表项_ 修罗飞书 { get; set; }

        public List<List<Point>> 包裹点位表 = new List<List<Point>> {
             new List<Point> {
                    new Point(591,192),
                    new Point(654,192),
                    new Point(720,192),
                    new Point(783,192),
                    new Point(848,192),
                    new Point(912,192),
                    new Point(976,192),
                    new Point(1041,192),

                    new Point(591,256),
                    new Point(654,256),
                    new Point(720,256),
                    new Point(783,256),
                    new Point(848,256),
                    new Point(912,256),
                    new Point(976,256),
                    new Point(1041,256),

                    new Point(591,318),
                    new Point(654,318),
                    new Point(720,318),
                    new Point(783,318),
                    new Point(848,318),
                    new Point(912,318),
                    new Point(976,318),
                    new Point(1041,318),

                    new Point(591,382),
                    new Point(654,382),
                    new Point(720,382),
                    new Point(783,382),
                    new Point(848,382),
                    new Point(912,382),
                    new Point(976,382),
                    new Point(1041,382),

                    new Point(591,443),
                    new Point(654,443),
                    new Point(720,443),
                    new Point(783,443),
                    new Point(848,443),
                    new Point(912,443),
                    new Point(976,443),
                    new Point(1041,443),

                    new Point(591,506),
                    new Point(654,506),
                    new Point(720,506),
                    new Point(783,506),
                    new Point(848,506),
                    new Point(912,506),
                    new Point(976,506),
                    new Point(1041,506)
                },
             new List<Point> {
                    new Point(591,192),
                    new Point(654,192),
                    new Point(720,192),
                    new Point(783,192),
                    new Point(848,192),
                    new Point(912,192),
                    new Point(976,192),
                    new Point(1041,192),

                    new Point(591,256),
                    new Point(654,256),
                    new Point(720,256),
                    new Point(783,256),
                    new Point(848,256),
                    new Point(912,256),
                    new Point(976,256),
                    new Point(1041,256),

                    new Point(591,318),
                    new Point(654,318),
                    new Point(720,318),
                    new Point(783,318),
                    new Point(848,318),
                    new Point(912,318),
                    new Point(976,318),
                    new Point(1041,318),

                    new Point(591,382),
                    new Point(654,382),
                    new Point(720,382),
                    new Point(783,382),
                    new Point(848,382),
                    new Point(912,382),
                    new Point(976,382),
                    new Point(1041,382),

                    new Point(591,443),
                    new Point(654,443),
                    new Point(720,443),
                    new Point(783,443),
                    new Point(848,443),
                    new Point(912,443),
                    new Point(976,443),
                    new Point(1041,443),

                    new Point(591,506),
                    new Point(654,506),
                    new Point(720,506),
                    new Point(783,506),
                    new Point(848,506),
                    new Point(912,506),
                    new Point(976,506),
                    new Point(1041,506)
                },
             new List<Point>
                {
                    new Point(591,192),
                    new Point(654,192),
                    new Point(720,192),
                    new Point(783,192),
                    new Point(848,192),
                    new Point(912,192),
                    new Point(976,192),
                    new Point(1041,192),

                    new Point(591,256),
                    new Point(654,256),
                    new Point(720,256),
                    new Point(783,256),
                    new Point(848,256),
                    new Point(912,256),
                    new Point(976,256),
                    new Point(1041,256),

                    new Point(591,318),
                    new Point(654,318),
                    new Point(720,318),
                    new Point(783,318),
                    new Point(848,318),
                    new Point(912,318),
                    new Point(976,318),
                    new Point(1041,318),

                    new Point(591,382)
                },
             new List<Point>
                {
                    new Point(497, 618),
                    new Point(568, 618),
                    new Point(639, 618),
                    new Point(711, 618),
                    new Point(780, 618)
                }
         };
        public 挂机人物_ 人物 { get; set; }
        public 包裹_(挂机人物_ 人物)
        {
            this.人物 = 人物;
        }

        public void 关闭极品回收后回收物品(bool 关闭 = false)
        {
            this.打开包裹();
            var 不必点击回收 = false;
            if (!其他_.循环判断(() =>
            {
                return 图像_.查找文字("装备回收", 264, 114, 357, 136).X != -1;
            }))
            {
                this.人物.输出("点击回收");
                键鼠_.左键单击(981, 623);
                其他_.延迟(其他_.时长_400);
            }
            else
            {
                this.人物.输出("回收窗口是打开的");
                不必点击回收 = true;
            }

            if (不必点击回收 || 其他_.循环判断(() =>
            {
                return 图像_.查找文字("装备回收", 264, 114, 357, 136).X != -1;
            }))
            {
                if (其他_.循环判断(() =>
                {
                    return 图像_.查找图片(Properties.Resources.包裹对号, 348, 498, 360, 510).X != -1;
                }, 2))
                {
                    this.人物.输出("关闭极品");
                    键鼠_.左键单击(353, 505);
                    其他_.延迟(其他_.时长_400);
                }
                this.人物.输出("回收物品");
                其他_.延迟(其他_.时长_600);
                键鼠_.左键单击(312, 601);
                其他_.循环判断(() =>
                {
                    var 有确定弹出 = UI_.弹出了确认窗口();
                    if (有确定弹出.X != -1)
                    {
                        键鼠_.左键单击(有确定弹出);
                        其他_.延迟(其他_.时长_600);
                        return true;
                    }
                    return false;
                }, 5, 500);
                键鼠_.左键单击(497, 118);
                其他_.延迟(其他_.时长_200);
            }
            if (关闭)
            {
                this.关闭包裹();
            }
        }

        public bool 包裹是打开的()
        {
            return 其他_.循环判断(() => 图像_.查找文字("整理", 955, 570, 1003, 590).X != -1, 4, 500);
        }
        public bool 包裹是关闭的()
        {
            return 其他_.循环判断(() => 图像_.查找文字("整理", 955, 570, 1003, 590).X == -1, 4, 500);
        }

        public bool 打开包裹()
        {
            if (包裹是关闭的())
            {
                键鼠_.左键单击(包裹图标位置);
                var 打开 = 包裹是打开的();
                if (!打开) throw new Exception("打开包裹失败");
            }
            return true;
        }

        public bool 关闭包裹()
        {
            if (包裹是打开的())
            {
                键鼠_.左键单击(包裹图标位置);
                var 已经关闭 = 包裹是关闭的();
                if (!已经关闭) throw new Exception("关闭包裹失败");
            }
            return true;
        }

        public int 所有物品总数()
        {
            return this.物品分类表.Sum() - 获取物品数量(_物品_.空包裹_);
        }

        public int 获取物品数量(_物品_ 物品索引)
        {
            return this.物品分类表[(int)物品索引];
        }

        public void 切换到第几页(int 序数 = 0, bool 关闭 = false, bool 已经打开包裹 = true)
        {
            if (!已经打开包裹)
            {
                打开包裹();
            }
            switch (序数)
            {
                default:
                    键鼠_.左键单击(第一页位置);
                    break;
                case 1:
                    键鼠_.左键单击(第二页位置);
                    break;
                case 2:
                    键鼠_.左键单击(第三页位置);
                    break;
            }
            其他_.延迟(其他_.时长_1000);
            if (关闭)
            {
                关闭包裹();
            }
        }

        private int 识别出物品剩余次数(Point 点位)
        {
            键鼠_.左键单击(点位.X - 10, 点位.Y - 10);
            其他_.延迟(其他_.时长_1000);
            var 内容 = "";
            var r = Rectangle.FromLTRB(点位.X + 2, 点位.Y + 76, 点位.X + 140, 点位.Y + 76 + 20);
            var 已识别 = 其他_.循环判断(() =>
            {
                内容 = 图像_.识别文字(r);
                return 内容 != "";
            }, 4, 500);
            键鼠_.左键单击(545, 117);
            其他_.延迟(其他_.时长_200);
            if (!已识别) return 1;
            var n = 其他_.尝试编译带斜杠号数字的分子(内容);
            if (n == 0) return 1;
            return n;
        }

        public 表项_ 识别包内物品详细信息(int 页, Point 点位, bool 需要换页 = false)
        {
            if (需要换页)
            {
                切换到第几页(页);
            }
            var 数量文本 = 图像_.识别文字(点位.X + 5, 点位.Y + 12, 点位.X + 32, 点位.Y + 32);
            人物.输出("识别出的数量: " + 数量文本);
            其他_.延迟(其他_.时长_400);
            键鼠_.左键单击(点位.X - 10, 点位.Y - 10);
            其他_.延迟(其他_.时长_1000);
            其他_.循环判断(() =>
            {
                var 内容 = 图像_.识别文字(点位.X, 点位.Y, 点位.X + 180, 点位.Y + 30);
                人物.输出("识别出的名字: " + 内容);
                return 内容 != "";
            });
            键鼠_.左键单击(545, 117);
            其他_.延迟(其他_.时长_200);
            return new 表项_(页, 点位, 0);
        }

        public bool 包裹内有物品(string 物品名称, bool 关闭 = false, bool 包裹已经打开 = true)
        {
            if (!包裹已经打开) 打开包裹();
            for (int n = 0; n < 包裹点位表.Count - 1; n++)
            {
                切换到第几页(n);
                for (int i = 0; i < 包裹点位表[n].Count; i++)
                {
                    var 位置 = 包裹点位表[n][i];
                    键鼠_.左键单击(位置.X, 位置.Y - 10);
                    其他_.延迟(其他_.时长_1000);
                    var 物品名 = 图像_.识别文字(位置.X, 位置.Y, 位置.X + 180, 位置.Y + 30);
                    其他_.延迟(其他_.时长_400);
                    键鼠_.左键单击(位置.X, 位置.Y - 10);
                    this.人物.输出("物品: " + 物品名);
                    if (物品名 == 物品名称)
                    {
                        return true;
                    }
                }
                if (关闭)
                {
                    关闭包裹();
                }
            }
            return false;
        }

        public Dictionary<string, int> 使用包内物品(List<物品及数量_> 使用的物品, bool 关闭 = false, bool 包裹已经打开 = true)
        {
            if (!包裹已经打开)  打开包裹();
            var dict = new Dictionary<string, int>();
            for (int n = 0; n < 包裹点位表.Count - 1; n++)
            {
                切换到第几页(n);
                其他_.延迟(其他_.时长_400);
                for (int i = 0; i < 包裹点位表[n].Count; i++)
                {
                    var 位置 = 包裹点位表[n][i];
                    键鼠_.左键单击(位置.X, 位置.Y - 10);
                    其他_.延迟(其他_.时长_1000);
                    var 物品名 = 图像_.识别文字(位置.X, 位置.Y, 位置.X + 180, 位置.Y + 30);
                    其他_.延迟(其他_.时长_400);
                    this.人物.输出("物品: " + 物品名);
                    var 是否使用 = 使用的物品.Find((t) => t.名称 == 物品名);
                    if (是否使用 != null)
                    {
                        if (dict.ContainsKey(是否使用.名称))
                        {
                            dict.TryGetValue(是否使用.名称, out int 值);
                            if (值 < 是否使用.数量)
                            {
                                dict[是否使用.名称] = 值 + 1;
                                键鼠_.左键双击(位置.X, 位置.Y - 10);
                                其他_.延迟(其他_.时长_400);
                            }
                        }
                    }
                }
                if (关闭)
                {
                    关闭包裹();
                }
            }
            return dict;
        }

        public int 使用包内物品(string 物品名称, int 使用数量, bool 关闭 = false, bool 包裹已经打开 = true)
        {
            if (!包裹已经打开) 打开包裹();
            var 结果 = 0;
            for (int n = 0; n < 包裹点位表.Count - 1; n++)
            {
                切换到第几页(n);
                for (int i = 0; i < 包裹点位表[n].Count; i++)
                {
                    if (使用数量 != -1 && 结果 == 使用数量) return 结果;
                    var 位置 = 包裹点位表[n][i];
                    键鼠_.左键单击(位置.X, 位置.Y - 10);
                    其他_.延迟(其他_.时长_1000);

                    var 物品名 = 图像_.识别文字(位置.X, 位置.Y, 位置.X + 180, 位置.Y + 30);

                    其他_.延迟(其他_.时长_400);
                    if (物品名 == 物品名称)
                    {
                        this.人物.输出("使用物品: " + 物品名);
                        结果++;
                        键鼠_.左键双击(位置.X, 位置.Y - 10);
                        其他_.延迟(其他_.时长_400);

                    }
                }
            }
            if (关闭)
            {
                关闭包裹();
            }
            return 结果;
        }

        public void 打开押镖礼盒()
        {
            使用包内物品(_物品_.押镖礼盒_, 1, this.使用包裹内押镖礼盒, true, false);
        }

        public void 使用包内物品(_物品_ 物品, int 数量, 使用包内物品_ fun, bool 关闭 = false, bool 包裹已经打开 = true)
        {
            if (!包裹已经打开) 打开包裹();
            var 结果 = 0;
            for (int n = 0; n < 包裹点位表.Count - 1; n++)
            {
                切换到第几页(n);
                for (int i = 0; i < 包裹点位表[n].Count; i++)
                {
                    var 位置 = 包裹点位表[n][i];
                    if (是什么物品(位置) == 物品)
                    {
                        结果++;
                        fun(人物, 位置);
                    }
                    if (结果 == 数量) goto 结束_;
                }
            }
        结束_:
            if (关闭)
            {
                关闭包裹();
            }
            return;
        }

        public void 使用包内物品(_物品_ 物品, int 数量, bool 关闭 = false, bool 包裹已经打开 = true)
        {
            使用包内物品(物品, 数量, (s, p) =>
            {
                键鼠_.左键单击(p);
                其他_.延迟(其他_.时长_400);
                return true;
            }, 关闭, 包裹已经打开);
        }

        public void 整理物品(bool 关闭 = false, bool 已经打开包裹 = true)
        {
            if (!已经打开包裹)  打开包裹();
            this.人物.输出("点击物品整理");
            键鼠_.左键单击(981, 579);
            其他_.延迟(其他_.时长_2000);
            if (关闭)
            {
                this.关闭包裹();
            }
        }

        public void 识别元宝数量(bool 关闭 = false, bool 已经打开包裹 = true)
        {
            if (!已经打开包裹) 打开包裹();
            var 元宝文本 = 图像_.识别文字(818, 590, 924, 625);
            try
            {
                this.元宝数量 = long.Parse(元宝文本.Trim());
                this.人物.输出("包裹元宝数量为: " + this.元宝数量.ToString());
            }
            catch
            {
                this.元宝数量 = -1;
            }
            其他_.延迟(其他_.时长_200);
            if (关闭)
            {
                关闭包裹();
            }
        }

        public void 识别快捷栏内物品(bool 统计 = false)
        {
            this.快捷随机位 = new Point(-1, -1);
            this.快捷回城石位 = new Point(-1, -1);
            var 点位组 = this.包裹点位表[3];
            for (int n = 0; n < 5; n++)
            {
                var 点位 = 点位组[n];
                var 物品 = 是什么物品(点位, 0.7);
                人物.输出("快捷栏: " + 物品.ToString());
                快捷栏[n] = 物品;
                if (统计)
                {
                    this.物品分类表[(int)物品] += 1;
                }
                if (物品 == _物品_.随机神石_)
                {
                    this.快捷随机位 = 点位;
                }
                if (物品 == _物品_.回城石_)
                {
                    this.快捷回城石位 = 点位;
                }
            }
        }

        public void 识别金币数量(bool 关闭 = false, bool 已经打开包裹 = true)
        {
            if (!已经打开包裹) 打开包裹();
            var 金币文本 = 图像_.识别文字(619, 590, 739, 625);
            try
            {
                this.金币数量 = long.Parse(金币文本.Trim());
                this.人物.输出("包裹金币数量为: " + this.金币数量.ToString());
            }
            catch
            {
                this.金币数量 = -1;
            }
            其他_.延迟(其他_.时长_200);
            if (关闭)
            {
                关闭包裹();
            }
        }

        public 表项_ 找到包裹内物品(_物品_ 物品, bool 关闭 = false, bool 已经打开包裹 = true)
        {

            if (!已经打开包裹) 打开包裹();
            for (int n = 0; n < 包裹点位表.Count - 1; n++)
            {
                切换到第几页(n);
                for (int i = 0; i < 包裹点位表[n].Count; i++)
                {
                    var 位置 = 包裹点位表[n][i];
                    if (this.是什么物品(位置) == 物品)
                    {
                        return new 表项_(n, 位置, 1);
                    }
                }
            }
            if (关闭)
            {
                关闭包裹();
            }
            return null;
        }

        public void 在包内找到随机神石移动到快捷栏()
        {
            var 找到 = 找到包裹内物品(_物品_.随机神石_, /*关闭包裹*/ false, /*已经打开包裹*/ false);
            if (找到 == null)
            {
                商城_.购买第一页物品(人物, new List<物品及数量_> { new 物品及数量_("随机神石", 1) });
                商城_.关闭商城(人物);
                关闭包裹();
                识别快捷栏内物品();
                if (this.快捷随机位.X != -1) return;
                整理包裹();
                找到 = 找到包裹内物品(_物品_.随机神石_);
            }
            if (找到 == null)
            {
                关闭包裹();
                return;
            }
            移动随机到快捷栏(找到.点);
            关闭包裹();
        }

        public bool 移动随机到快捷栏(Point 随机神石)
        {
            键鼠_.移动鼠标(随机神石);
            其他_.延迟(其他_.时长_100);
            键鼠_.左键按下();
            其他_.延迟(其他_.时长_100);
            键鼠_.移动鼠标(492, 617);
            其他_.延迟(其他_.时长_100);
            键鼠_.左键抬起();
            其他_.延迟(其他_.时长_200);
            this.快捷随机位 = this.包裹点位表[3][0];
            this.快捷栏[0] = _物品_.随机神石_;
            return true;
        }

        private bool 使用包裹内押镖礼盒(挂机人物_ 人物, Point 位置)
        {
            键鼠_.左键双击(位置);
            var 成功 = 其他_.循环判断(() => 图像_.查找文字("抽", 199, 469, 225, 492).X != -1 &&
            图像_.查找文字("奖", 234, 469, 258, 492).X != -1, 5);
            if (成功)
            {
                键鼠_.左键单击(229, 480);
                成功 = 其他_.循环判断(() => 图像_.查找文字("领", 199, 469, 225, 492).X != -1 &&
            图像_.查找文字("取", 234, 469, 258, 492).X != -1, 10);
                其他_.延迟(其他_.时长_2000);
                键鼠_.左键单击(227, 332);
                var i = 0;
                var s = "";
                do
                {
                    s = 图像_.识别文字(234, 337, 396, 363);
                    if (s != "") 人物.输出("押镖礼盒获得: " + s);
                    i++;
                    其他_.延迟(其他_.时长_400);
                }
                while (i < 5 && s == "");
                键鼠_.左键单击(229, 480);
                成功 = 其他_.循环判断(() => !(图像_.查找文字("领", 199, 469, 225, 492).X != -1), 5);
                return 成功;
            }
            return false;
        }

        public void 使用项(Point 当前点, out _物品_ 物品, out bool 有操作)
        {
            键鼠_.左键双击(当前点);
            其他_.延迟(其他_.时长_400);
            物品 = _物品_.空包裹_;
            人物.输出("直接使用: " + 物品.ToString());
            有操作 = true;
        }

        private void 合并项(ref Point 第一个, ref bool 有操作, Point 当前点, _物品_ 物品)
        {
            if (第一个 == Point.Empty)
            {
                第一个 = 当前点;
            }
            else
            {
                键鼠_.移动鼠标(当前点);
                其他_.延迟(其他_.时长_100);
                键鼠_.左键按下();
                其他_.延迟(其他_.时长_100);
                键鼠_.移动鼠标(第一个);
                其他_.延迟(其他_.时长_100);
                键鼠_.左键抬起();
                其他_.延迟(其他_.时长_200);
                人物.输出("合并 " + 物品.ToString());
                有操作 = true;
            }
        }

        public void 整理包裹(bool 关闭 = false, bool 不识别物品详细信息 = false)
        {
            识别快捷栏内物品(true);
            this.关闭极品回收后回收物品();
            物品分类表 = new int[(int)_物品_.最大_];
            var 有操作 = false;
            整理物品(/*关闭包裹*/ false, /*已经打开包裹*/ false);
            识别金币数量();
            识别元宝数量();
            for (int n = 0; n < 包裹点位表.Count - 1; n++)
            {
                Point 第一个精修 = Point.Empty;
                Point 第一个杜康 = Point.Empty;
                Point 第一个纪念币 = Point.Empty;
                切换到第几页(n);
                foreach (var 当前点位 in 包裹点位表[n])
                {
                    _物品_ 是什么物品 = this.是什么物品(当前点位);
                    人物.输出("当前: " + 是什么物品.ToString());
                    if (!不识别物品详细信息)
                    {
                        switch (是什么物品)
                        {
                            case _物品_.雌人_:
                            case _物品_.红毒_:
                                {
                                    var 次数 = 识别出物品剩余次数(当前点位);
                                    人物.输出("红毒次数加: " + 次数);
                                    人物.红毒次数 += 次数;
                                    break;
                                }
                            case _物品_.雄人_:
                            case _物品_.绿毒_:
                                {
                                    var 次数 = 识别出物品剩余次数(当前点位);
                                    人物.输出("绿毒次数加: " + 次数);
                                    人物.绿毒次数 += 次数;
                                    break;
                                }
                            case _物品_.道符_:
                                {
                                    var 次数 = 识别出物品剩余次数(当前点位);
                                    人物.输出("道符次数加: " + 次数);
                                    人物.道符次数 += 次数;
                                    break;
                                }
                            case _物品_.冰泉圣水_:
                                {
                                    var 次数 = 识别出物品剩余次数(当前点位);
                                    人物.输出("冰泉次数加: " + 次数);
                                    人物.冰泉次数 += 次数;
                                    break;
                                }
                            case _物品_.随机神石_:
                                {
                                    var 次数 = 识别出物品剩余次数(当前点位);
                                    人物.输出("随机次数加: " + 次数);
                                    人物.随机次数 += 次数;
                                    if (次数 > 20)
                                    {
                                        移动随机到快捷栏(当前点位);
                                    }
                                    break;
                                }
                            case _物品_.低级飞行符_:
                            case _物品_.飞书残片_:
                                {
                                    识别包内物品详细信息(n, 当前点位);
                                    break;
                                }
                            case _物品_.红包_:
                            case _物品_.炼狱时间_:
                            case _物品_.金条_:
                            case _物品_.金砖_:
                                {
                                    使用项(当前点位, out 是什么物品, out 有操作);
                                    break;
                                }
                            case _物品_.精修卷轴_:
                                {
                                    合并项(ref 第一个精修, ref 有操作, 当前点位, 是什么物品);
                                    if (第一个精修 != Point.Empty) 是什么物品 = _物品_.空包裹_;
                                    break;
                                }
                            case _物品_.杜康酒_:
                                {
                                    合并项(ref 第一个杜康, ref 有操作, 当前点位, 是什么物品);
                                    if (第一个杜康 != Point.Empty) 是什么物品 = _物品_.空包裹_;
                                    break;
                                }
                            case _物品_.纪念币_:
                                {
                                    合并项(ref 第一个纪念币, ref 有操作, 当前点位, 是什么物品);
                                    if (第一个纪念币 != Point.Empty) 是什么物品 = _物品_.空包裹_;
                                    break;
                                }
                            case _物品_.未解锁_:
                                goto _结束;
                        }
                    }
                    else if (是什么物品 == _物品_.未解锁_)
                    {
                        goto _结束;
                    }
                    this.物品分类表[(int)是什么物品] += 1;
                }
            }
        _结束:
            if (有操作)
            {
                整理物品();
            }
            切换到第几页();
            if (关闭)
            {
                关闭包裹();
            }
        }

        public Rectangle 获取范围(Point 中心点)
        {
            return Rectangle.FromLTRB(中心点.X - 35, 中心点.Y - 35, 中心点.X + 35, 中心点.Y + 35);
        }

        public bool 是空格包裹(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.空包裹, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是未解锁包裹(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.未解锁包裹, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是治疗药水(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.治疗药水, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是太阳神水(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.强效太阳神水, 获取范围(中心点), 0.9).X != -1;
        }

        public bool 是特级金创药包(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.特级金创药包, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是特级魔法药包(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.特级魔法药包, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是特级魔法药(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.特级魔法药, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是特级金创药(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.特级金创药, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是道符(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.道尊神符, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是红毒(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.道尊红毒, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是绿毒(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.道尊绿毒, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是雌人(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.超级雌稻草人, 获取范围(中心点), 0.9).X != -1;
        }

        public bool 是雄人(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.超级雄稻草人, 获取范围(中心点), 0.9).X != -1;
        }

        public bool 是祝福神油(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.祝福神油, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是叶子(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.叶子, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是果实(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.果实, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是牙齿(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.牙齿, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是蟾酥(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.蟾酥, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是蛆卵(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.蛆卵, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是蝎尾(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.蝎尾, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是天玉宝石(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.天玉宝石, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是杜康酒(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.杜康酒, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是炼狱时间(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.炼狱时间, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是纪念币(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.纪念币, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是金条(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.金条, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是金砖(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.金砖, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是红包(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.红包, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是飞书残片(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.飞书残片, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是低级飞行符(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.低级飞行符, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是精修卷轴(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.精修卷轴, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是押镖礼盒(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.押镖礼盒, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是冰泉圣水(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.冰泉圣水, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是随机神石(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.随机神石, 获取范围(中心点), 精确值).X != -1;
        }

        public bool 是回城石(Point 中心点, double 精确值 = 0.8)
        {
            return 图像_.查找图片(Properties.Resources.回城石, 获取范围(中心点), 精确值).X != -1;
        }

        public _物品_ 是什么物品(Point 当前点位, double 精确值 = 0.8)
        {
            if (this.是未解锁包裹(当前点位, 精确值))
            {
                return _物品_.未解锁_;
            }
            else if (this.是空格包裹(当前点位, 精确值))
            {
                return _物品_.空包裹_;
            }
            else if (this.是治疗药水(当前点位, 精确值))
            {
                return _物品_.治疗药水_;
            }
            else if (this.是太阳神水(当前点位, 精确值))
            {
                return _物品_.太阳神水_;
            }
            else if (this.是特级金创药(当前点位, 精确值))
            {
                return _物品_.特级金创药_;
            }
            else if (this.是特级魔法药(当前点位, 精确值))
            {
                return _物品_.特级魔法药_;
            }
            else if (this.是特级金创药包(当前点位, 精确值))
            {
                return _物品_.特级金创药包_;
            }
            else if (this.是特级魔法药包(当前点位, 精确值))
            {
                return _物品_.特级魔法药包_;
            }
            else if (this.是冰泉圣水(当前点位, 精确值))
            {
                return _物品_.冰泉圣水_;
            }
            else if (this.是随机神石(当前点位, 精确值))
            {
                return _物品_.随机神石_;
            }
            else if (this.是回城石(当前点位, 精确值))
            {
                return _物品_.回城石_;
            }
            else if (this.是道符(当前点位, 精确值))
            {
                return _物品_.道符_;
            }
            else if (this.是红毒(当前点位, 精确值))
            {
                return _物品_.红毒_;
            }
            else if (this.是绿毒(当前点位, 精确值))
            {
                return _物品_.绿毒_;
            }
            else if (this.是雌人(当前点位, 精确值))
            {
                return _物品_.雌人_;
            }
            else if (this.是雄人(当前点位, 精确值))
            {
                return _物品_.雄人_;
            }
            else if (this.是天玉宝石(当前点位, 精确值))
            {
                return _物品_.天玉宝石_;
            }
            else if (this.是杜康酒(当前点位, 精确值))
            {
                return _物品_.杜康酒_;
            }
            else if (this.是炼狱时间(当前点位, 精确值))
            {
                return _物品_.炼狱时间_;
            }
            else if (this.是纪念币(当前点位, 精确值))
            {
                return _物品_.纪念币_;
            }
            else if (this.是金条(当前点位, 精确值))
            {
                return _物品_.金条_;
            }
            else if (this.是金砖(当前点位, 精确值))
            {
                return _物品_.金砖_;
            }
            else if (this.是红包(当前点位, 精确值))
            {
                return _物品_.红包_;
            }
            else if (this.是飞书残片(当前点位, 精确值))
            {
                return _物品_.飞书残片_;
            }
            else if (this.是低级飞行符(当前点位, 精确值))
            {
                return _物品_.低级飞行符_;
            }
            else if (this.是精修卷轴(当前点位, 精确值))
            {
                return _物品_.精修卷轴_;
            }
            else if (this.是押镖礼盒(当前点位, 精确值))
            {
                return _物品_.押镖礼盒_;
            }
            else if (this.是祝福神油(当前点位, 精确值))
            {
                return _物品_.祝福神油_;
            }
            else if (this.是叶子(当前点位, 精确值))
            {
                return _物品_.叶子_;
            }
            else if (this.是果实(当前点位, 精确值))
            {
                return _物品_.果实_;
            }
            else if (this.是牙齿(当前点位, 精确值))
            {
                return _物品_.牙齿_;
            }
            else if (this.是蟾酥(当前点位, 精确值))
            {
                return _物品_.蟾酥_;
            }
            else if (this.是蛆卵(当前点位, 精确值))
            {
                return _物品_.蛆卵_;
            }
            else if (this.是蝎尾(当前点位, 精确值))
            {
                return _物品_.蝎尾_;
            }
            else
            {
                return _物品_.其他_;
            }
        }
    }

    public enum _物品_ : int
    {
        其他_,
        空包裹_,
        治疗药水_,
        太阳神水_,
        特级金创药_,
        特级魔法药_,
        特级金创药包_,
        特级魔法药包_,
        道符_,
        绿毒_,
        红毒_,
        雄人_,
        雌人_,
        冰泉圣水_,
        随机神石_,
        回城石_,
        天玉宝石_,
        杜康酒_,
        炼狱时间_,
        纪念币_,
        金条_,
        金砖_,
        红包_,
        飞书残片_,
        低级飞行符_,
        精修卷轴_,
        押镖礼盒_,

        祝福神油_,
        叶子_,
        果实_,
        牙齿_,
        蟾酥_,
        蛆卵_,
        蝎尾_,
        未解锁_,
        最大_ = 未解锁_,
    }
}
